// #include <iostream>
// #include <fcntl.h>
// #include <termios.h>
// #include <unistd.h>
// #include <cstring>

// int main() {
//     // Open the serial port
//     int serial_port = open("/dev/ttyS0", O_RDWR);

//     // Check for errors
//     if (serial_port < 0) {
//         std::cerr << "Error " << errno << " opening /dev/ttyS0: " << strerror(errno) << std::endl;
//         return 1;
//     }

//     // Configure the serial port
//     struct termios tty;
//     memset(&tty, 0, sizeof tty);

//     // Read in existing settings, and handle any error
//     if (tcgetattr(serial_port, &tty) != 0) {
//         std::cerr << "Error " << errno << " from tcgetattr: " << strerror(errno) << std::endl;
//         return 1;
//     }

//     // Set Baud Rate
//     cfsetospeed(&tty, B9600);
//     cfsetispeed(&tty, B9600);

//     // Setting other Port Stuff
//     tty.c_cflag &= ~PARENB; // Make 8n1
//     tty.c_cflag &= ~CSTOPB;
//     tty.c_cflag &= ~CSIZE;
//     tty.c_cflag |= CS8;

//     tty.c_cflag &= ~CRTSCTS; // No flow control
//     tty.c_cflag |= CREAD | CLOCAL; // Turn on READ & ignore ctrl lines (CLOCAL = 1)

//     tty.c_lflag &= ~ICANON;
//     tty.c_lflag &= ~ECHO; // Disable echo
//     tty.c_lflag &= ~ECHOE; // Disable erasure
//     tty.c_lflag &= ~ECHONL; // Disable new-line echo
//     tty.c_lflag &= ~ISIG; // Disable interpretation of INTR, QUIT and SUSP
//     tty.c_iflag &= ~(IXON | IXOFF | IXANY); // Turn off s/w flow ctrl
//     tty.c_iflag &= ~(ICRNL | INLCR); // Disable CR to NL translation
//     tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL); // Disable any special handling of received bytes

//     tty.c_oflag &= ~OPOST; // Prevent special interpretation of output bytes (e.g. newline chars)
//     tty.c_oflag &= ~ONLCR; // Prevent conversion of newline to carriage return/line feed

//     // Set in/out baud rate to be 9600
//     cfsetispeed(&tty, B9600);
//     cfsetospeed(&tty, B9600);

//     // Save tty settings, also checking for error
//     if (tcsetattr(serial_port, TCSANOW, &tty) != 0) {
//         std::cerr << "Error " << errno << " from tcsetattr: " << strerror(errno) << std::endl;
//         return 1;
//     }

//     // Write to serial port
//     const char *msg = "Hello STM32!";
//     write(serial_port, msg, strlen(msg));

//     // Allocate memory for read buffer, set size according to your needs
//     char read_buf[256];
//     memset(&read_buf, '\0', sizeof(read_buf));

//     // Read from serial port
//     int num_bytes = read(serial_port, &read_buf, sizeof(read_buf));

//     // Check for errors
//     if (num_bytes < 0) {
//         std::cerr << "Error reading: " << strerror(errno) << std::endl;
//         return 1;
//     }

//     // Print read data
//     std::cout << "Read " << num_bytes << " bytes. Received message: " << read_buf << std::endl;

//     // Close the serial port
//     close(serial_port);

//     return 0;
// }
/****************termios 处理过程************************/
// #include <iostream>
// #include <unistd.h>
// #include <fcntl.h>
// #include <termios.h>
// #include <cstring>

// using namespace std;

// // 配置串口的函数
// void configureSerialPort(int fd, int baudRate, int dataBits, int stopBits, char parity) {
//     struct termios options;

//     // 获取当前串口的设置
//     if (tcgetattr(fd, &options) < 0) {
//         cerr << "Error getting serial port attributes" << endl;
//         return;
//     }

//     // 设置波特率
//     cfsetispeed(&options, baudRate);
//     cfsetospeed(&options, baudRate);

//     // 设置数据位（通常为 8 位）
//     options.c_cflag &= ~CSIZE;  // 清除数据位设置
//     switch (dataBits) {
//         case 5: options.c_cflag |= CS5; break;
//         case 6: options.c_cflag |= CS6; break;
//         case 7: options.c_cflag |= CS7; break;
//         case 8: options.c_cflag |= CS8; break;
//         default:
//             cerr << "Invalid data bits" << endl;
//             return;
//     }

//     // 设置停止位
//     if (stopBits == 1) {
//         options.c_cflag &= ~CSTOPB;  // 1 位停止位
//     } else if (stopBits == 2) {
//         options.c_cflag |= CSTOPB;   // 2 位停止位
//     } else {
//         cerr << "Invalid stop bits" << endl;
//         return;
//     }

//     // 设置校验位
//     if (parity == 'N') {
//         options.c_cflag &= ~PARENB;  // 无校验
//         options.c_iflag &= ~INPCK;   // 不启用输入校验
//     } else if (parity == 'O') {
//         options.c_cflag |= PARENB;   // 开启校验
//         options.c_cflag |= PARODD;   // 奇校验
//         options.c_iflag |= INPCK;    // 启用输入校验
//     } else if (parity == 'E') {
//         options.c_cflag |= PARENB;   // 开启校验
//         options.c_cflag &= ~PARODD;  // 偶校验
//         options.c_iflag |= INPCK;    // 启用输入校验
//     } else {
//         cerr << "Invalid parity option" << endl;
//         return;
//     }

//     // 使能串口配置并关闭硬件流控制
//     options.c_cflag |= (CLOCAL | CREAD);  // 启用接收并忽略调制解调器控制线
//     options.c_cflag &= ~CRTSCTS;          // 禁用硬件流控制

//     // 设置串口为原始模式
//     options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);

//     // 设置数据传输时的字符大小，接收超时等
//     options.c_cc[VMIN] = 1;    // 至少读取 1 字节数据
//     options.c_cc[VTIME] = 5;   // 超时 0.5 秒

//     // 应用配置
//     if (tcsetattr(fd, TCSANOW, &options) < 0) {
//         cerr << "Error setting serial port attributes" << endl;
//         return;
//     }
// }

// // 读取串口数据
// void readFromSerial(int fd) {
//     char buf[256];
//     int n = read(fd, buf, sizeof(buf) - 1);
//     if (n < 0) {
//         cerr << "Read error" << endl;
//         return;
//     }
//     buf[n] = '\0';
//     cout << "Received data: " << buf << endl;
// }

// // 写入串口数据
// void writeToSerial(int fd, const char* data) {
//     int len = strlen(data);
//     int n = write(fd, data, len);
//     if (n < 0) {
//         cerr << "Write error" << endl;
//         return;
//     }
//     cout << "Sent data: " << data << endl;
// }

// int main() {
//     // 打开串口设备
//     const char* device = "/dev/ttyS0";  // 这里使用的是 /dev/ttyS0，可以根据实际情况修改
//     int fd = open(device, O_RDWR | O_NOCTTY | O_NDELAY);
//     if (fd == -1) {
//         cerr << "Failed to open serial port " << device << endl;
//         return -1;
//     }

//     // 配置串口：波特率为 9600，数据位 8，停止位 1，无校验
//     configureSerialPort(fd, B115200, 8, 1, 'N');

//     // 向 STM32 发送数据
//     const char* dataToSend = "Hello STM32!";
//     writeToSerial(fd, dataToSend);

//     // 从 STM32 读取数据
//     readFromSerial(fd);

//     // 关闭串口
//     close(fd);

//     return 0;
// }
/*文件说明:初步采用查询的方式进行数据处理，
*/
#include <iostream>
#include <stdio.h> 
#include <errno.h>
#include <string.h>
/*
  unistd.h 是 Linux 和 Unix 系统中的一个关键头文件，
  它提供了许多与系统调用和底层操作有关的函数、常量和类型的声明。
  一些常见的函数和常量:
*/
#include <unistd.h>
#include "wiringPi.h"
#include "wiringSerial.h" //使用wiringPi串口函数库
 
int main(int argc, char *argv[])
{
    int serialPort;
    if ((serialPort = serialOpen("/dev/ttyAMA0", 115200)) < 0) //初始化串口并获取文件描述符保存到fd变量里
    {
     fprintf(stderr, "Unable to open serial device: %s\n", strerror(errno));
     return 1 ;
    }
 
    serialPuts(serialPort, "Raspi Zero W UART Test Start!");
    std::cout << "Ready to Receive" << std::endl;
    const int bufferSize = 256; // 缓冲区大小
    char buffer[bufferSize];
    int index = 0; // 当前缓冲区索引
    memset(buffer, 0, bufferSize); // 初始化缓冲区

    // 读取数据
    while (true) {
        if (serialDataAvail(serialPort)) {
            char data = serialGetchar(serialPort); // 读取一个字符

            // 如果接收到换行符（假设STM32以换行符结束数据）
            if (data == '\n') {
                buffer[index] = '\0'; // 添加字符串结束符
                std::cout << "receive_data: " << buffer << std::endl;
                index = 0; // 重置缓冲区索引
                memset(buffer, 0, bufferSize); // 清空缓冲区
                serialPuts(serialPort, "hello stm32");
                std::cout << "发送完成" << std::endl;
            } else {
                if (index < bufferSize - 1) { // 防止缓冲区溢出
                    buffer[index++] = data; // 存储数据到缓冲区
                } else {
                    std::cerr << "buff full: " << buffer << std::endl;
                    index = 0; // 重置缓冲区索引
                    memset(buffer, 0, bufferSize); // 清空缓冲区
                    serialPuts(serialPort, "hello stm32");
                    std::cout << "发送完成" << std::endl;
                }
            }
        }
        usleep(100); // 延迟100us，避免CPU占用过高
    }

    // 关闭串口
    serialClose(serialPort);
 
    return 0;
}
